// 删除顶部的直接引用
// const app = getApp()

/**
 * 网络请求封装
 */
class Request {
  constructor() {
    // 配置环境变量
    const env = {
      development: 'http://localhost:8080/api',
      production: 'https://api.foodorder.com/api',
      // 通过云函数转发API请求，解决小程序域名限制问题
      cloud: 'https://api.weixin.qq.com/tcb/invokecloudfunction'
    }

    // 当前环境 - 默认开发环境
    this.currentEnv = 'development'
    
    // 根据环境设置baseURL
    this.baseURL = env[this.currentEnv]
    
    // 超时设置
    this.timeout = 15000
    
    // 是否使用模拟数据
    this.useMock = false // 使用真实后端API
    
    console.log(`[Request] 初始化API环境: ${this.currentEnv}, baseURL: ${this.baseURL}`)
  }

  /**
   * 发起请求
   */
  request(options) {
    return new Promise((resolve, reject) => {
      // 显示加载提示
      if (options.loading !== false) {
        wx.showLoading({
          title: options.loadingText || '加载中...',
          mask: true
        })
      }

      // 构建完整URL
      const url = options.url.startsWith('http') 
        ? options.url 
        : this.baseURL + options.url

      // 获取app实例和token
      const app = getApp()
      const token = wx.getStorageSync('token') || (app && app.globalData ? app.globalData.token : null)

      // 设置请求头
      const header = {
        'Content-Type': 'application/json',
        ...options.header
      }

      if (token) {
        header.Authorization = `Bearer ${token}`
      }
      
      // 判断是否使用模拟数据
      if (this.useMock && options.mock) {
        console.log(`[API模拟] ${options.method || 'GET'} ${options.url}`)
        setTimeout(() => {
          wx.hideLoading()
          // 返回模拟数据
          resolve({
            code: 200,
            message: 'success',
            data: options.mock
          })
        }, 500)
        return
      }

      // 发起真实请求
      wx.request({
        url,
        method: options.method || 'GET',
        data: options.data,
        header,
        timeout: options.timeout || this.timeout,
        success: (res) => {
          wx.hideLoading()

          // 处理HTTP状态码
          if (res.statusCode >= 200 && res.statusCode < 300) {
            // 处理业务状态码 - 统一使用code=200判断成功
            const isSuccess = res.data.code === 200
            
            if (isSuccess) {
              resolve(res.data)
            } else {
              // 业务错误
              const error = new Error(res.data.message || '请求失败')
              error.code = res.data.code
              error.data = res.data
              reject(error)
            }
          } else if (res.statusCode === 401) {
            // 未授权，需要重新登录
            this.handleUnauthorized()
            reject(new Error('登录已过期，请重新登录'))
          } else {
            // HTTP错误
            const error = new Error(`HTTP ${res.statusCode}`)
            error.statusCode = res.statusCode
            reject(error)
          }
        },
        fail: (error) => {
          wx.hideLoading()
          
          // 网络错误处理
          let message = '网络错误'
          if (error.errMsg.includes('timeout')) {
            message = '请求超时'
          } else if (error.errMsg.includes('fail')) {
            message = '网络连接失败'
          }
          
          const networkError = new Error(message)
          networkError.originalError = error
          
          // 如果有模拟数据且允许降级
          if (this.useMock && options.mock && options.fallbackToMock !== false) {
            console.log(`[API降级] ${options.method || 'GET'} ${options.url} 降级到模拟数据`)
            resolve({
              code: 200,
              message: 'success (mock fallback)',
              data: options.mock
            })
          } else {
            reject(networkError)
          }
        }
      })
    })
  }

  /**
   * 处理未授权状态
   */
  handleUnauthorized() {
    // 清除登录信息
    wx.removeStorageSync('token')
    wx.removeStorageSync('userInfo')
    
    // 获取app实例
    const app = getApp()
    if (app && app.globalData) {
      app.globalData.token = null
      app.globalData.userInfo = null
    }
    
    // 弹窗提示
    wx.showModal({
      title: '登录已过期',
      content: '请重新登录',
      showCancel: false,
      success: () => {
        // 跳转到登录页
        wx.navigateTo({
          url: '/pages/login/login'
        })
      }
    })
  }

  /**
   * GET请求
   */
  get(url, data, options = {}) {
    return this.request({
      url,
      method: 'GET',
      data,
      ...options
    })
  }

  /**
   * POST请求
   */
  post(url, data, options = {}) {
    return this.request({
      url,
      method: 'POST',
      data,
      ...options
    })
  }

  /**
   * PUT请求
   */
  put(url, data, options = {}) {
    return this.request({
      url,
      method: 'PUT',
      data,
      ...options
    })
  }

  /**
   * DELETE请求
   */
  delete(url, data, options = {}) {
    return this.request({
      url,
      method: 'DELETE',
      data,
      ...options
    })
  }

  /**
   * 上传文件
   */
  upload(url, filePath, options = {}) {
    return new Promise((resolve, reject) => {
      wx.showLoading({
        title: '上传中...',
        mask: true
      })

      const token = wx.getStorageSync('token') || app.globalData.token
      const header = {
        ...options.header
      }

      if (token) {
        header.Authorization = `Bearer ${token}`
      }

      wx.uploadFile({
        url: url.startsWith('http') ? url : this.baseURL + url,
        filePath,
        name: options.name || 'file',
        formData: options.formData,
        header,
        success: (res) => {
          wx.hideLoading()
          
          try {
            const data = JSON.parse(res.data)
            const isSuccess = data.success === true || data.code === 200
            
            if (isSuccess) {
              resolve(data)
            } else {
              reject(new Error(data.message || '上传失败'))
            }
          } catch (error) {
            reject(new Error('响应格式错误'))
          }
        },
        fail: (error) => {
          wx.hideLoading()
          reject(new Error('上传失败'))
        }
      })
    })
  }
  
  /**
   * 设置API环境
   */
  setEnvironment(env) {
    if (env === 'production') {
      this.currentEnv = 'production'
      this.baseURL = 'https://api.foodorder.com/api'
      this.useMock = false
    } else if (env === 'cloud') {
      this.currentEnv = 'cloud'
      this.baseURL = 'https://api.weixin.qq.com/tcb/invokecloudfunction'
      this.useMock = false
    } else {
      this.currentEnv = 'development'
      this.baseURL = 'http://localhost:8080/api'
      this.useMock = true
    }
    
    console.log(`[Request] 切换API环境: ${this.currentEnv}, baseURL: ${this.baseURL}`)
    return this
  }
  
  /**
   * 启用/禁用模拟数据
   */
  setMockEnabled(enabled) {
    this.useMock = enabled
    console.log(`[Request] ${enabled ? '启用' : '禁用'}模拟数据`)
    return this
  }
}

// 创建实例
const request = new Request()

// 请求拦截器
request.interceptors = {
  // 请求前拦截
  request: (config) => {
    // 可以在这里添加通用的请求处理逻辑
    return config
  },
  
  // 响应拦截
  response: (response) => {
    // 可以在这里添加通用的响应处理逻辑
    return response
  },
  
  // 错误拦截
  error: (error) => {
    // 统一错误处理
    console.error('请求错误:', error)
    
    // 根据错误类型显示不同提示
    if (error.code === 401) {
      wx.showModal({
        title: '登录过期',
        content: '请重新登录',
        showCancel: false,
        success: () => {
          // 清除登录信息
          wx.removeStorageSync('token')
          wx.removeStorageSync('userInfo')
          app.globalData.token = null
          app.globalData.userInfo = null
          
          // 跳转到登录页
          wx.navigateTo({
            url: '/pages/login/login'
          })
        }
      })
    } else if (error.message) {
      wx.showToast({
        title: error.message,
        icon: 'none',
        duration: 2000
      })
    }
    
    return Promise.reject(error)
  }
}

module.exports = request